{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Fractional Differencing\n",
    "\n",
    "### Background\n",
    "Fractional Differencing is a signal processing technique that is used to remove the non-stationarity from the time series while maintaining as much memory as possible. It is widely used in FSI to prepare training data for machine learning algorithms. In this [open-source project](https://github.com/ritchieng/fractional_differencing_gpu/blob/master/notebooks/gpu_fractional_differencing.ipynb) done by Ensemble Capital, fractional differencing computation is accelerated via `cudf.appy_chunk` method in the GPU. It achieves hundreds of times acceleration compared with CPU implementation in their [report](https://www.researchgate.net/publication/335159299_GFD_GPU_Fractional_Differencing_for_Rapid_Large-scale_Stationarizing_of_Time_Series_Data_while_Minimizing_Memory_Loss). \n",
    "Using `apply_rows` and `apply_chunks` method from the cudf library is the easiest way of customizing GPU computations as covered in this [blog](https://medium.com/rapids-ai/user-defined-functions-in-rapids-cudf-2d7c3fc2728d). However, it is not the most efficient way.\n",
    "\n",
    "In this notebook, we are going to show how to use Numba to do fractional differencing computation efficiently. As gQuant wrap the fractional differencing function in the computation node, we are going to show it is easy for data scientists to compute fractional differencing signals and use them to generate alpha signals. \n",
    "\n",
    "### Environment Preparation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sys; sys.path.insert(0, '..')\n",
    "\n",
    "import warnings\n",
    "import gquant\n",
    "from gquant.cuindicator import get_weights_floored, fractional_diff\n",
    "import ipywidgets as widgets\n",
    "import os\n",
    "import time\n",
    "import numpy as np\n",
    "from numba import cuda\n",
    "import cudf\n",
    "import inspect\n",
    "from numba import njit\n",
    "from numba import prange\n",
    "warnings.simplefilter(\"ignore\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Copy the fractional differencing code from the [open-source project](https://github.com/ritchieng/fractional_differencing_gpu/blob/master/notebooks/gpu_fractional_differencing.ipynb). We will use this as our benchmark reference"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def moving_dot_product_kernel(in_data, out, window_size, weights):\n",
    "    # Set the first window_size-1 rows in each chunk to np.nan due \n",
    "    # insufficient history\n",
    "    for i in range(cuda.threadIdx.x, window_size - 1, cuda.blockDim.x):\n",
    "        out[i] = np.nan\n",
    "    \n",
    "    # Compute dot product of preceding window_size rows\n",
    "    for i in range(cuda.threadIdx.x + window_size - 1, in_data.size, cuda.blockDim.x):\n",
    "        rolling_dot_product = 0.0\n",
    "        \n",
    "        k = 0\n",
    "        for j in range(i - window_size + 1, i + 1):\n",
    "            rolling_dot_product += in_data[j] * weights[k][0]\n",
    "            k += 1\n",
    "        \n",
    "        out[i] = rolling_dot_product \n",
    "        \n",
    "def frac_diff_gpu(df, d, floor=1e-3):\n",
    "    r\"\"\"Fractionally difference time series via GPU.\n",
    "    \n",
    "    Args:\n",
    "        df (pd.DataFrame): dataframe of raw time series values.\n",
    "        d (float): differencing value from 0 to 1 where > 1 has no FD.\n",
    "        floor (float): minimum value of weights, ignoring anything smaller.\n",
    "    \"\"\"\n",
    "    \n",
    "    # Bring dataframe to GPU, reset index for GPU dot product kernel\n",
    "    # gdf_raw = cudf.from_pandas(df).reset_index(drop=True)\n",
    "    gdf_raw = df\n",
    "    gdf_raw.columns = ['in_data']\n",
    "\n",
    "    # Get weights window\n",
    "    weights = get_weights_floored(d=d, num_k=len(gdf_raw), floor=floor)\n",
    "    weights_window_size = len(weights)\n",
    "    \n",
    "    # Reverse weights and as contiguous\n",
    "    weights = np.ascontiguousarray(weights[::-1])\n",
    "    \n",
    "    # Bring weights to GPU\n",
    "    gdf_weights = cudf.DataFrame()\n",
    "    gdf_weights[gdf_raw.columns[0]] = weights.reshape(-1)\n",
    "\n",
    "    # Length of data\n",
    "    data_length = len(gdf_raw)\n",
    "\n",
    "    # T4: max of 518 threads per block.\n",
    "    # V100: max 1024 threads per block\n",
    "    threads_per_block = 518\n",
    "\n",
    "    # Chunk size split\n",
    "    # This has to be improved, but as a v0.1, it's sufficient to show speed-up\n",
    "    # Up to easily 100 million data points\n",
    "    trunk_size = data_length\n",
    "\n",
    "    # Get fractionally differenced time series through GPU function\n",
    "    gdf_raw_fd = gdf_raw.apply_chunks(moving_dot_product_kernel,\n",
    "                                 incols=['in_data'],\n",
    "                                 outcols=dict(out=np.float64),\n",
    "                                 kwargs=dict(window_size=weights_window_size, weights=weights),\n",
    "                                 chunks=list(range(0, data_length, trunk_size)) + [data_length],\n",
    "                                 tpb=threads_per_block)\n",
    "    \n",
    "    # Bring to CPU for normal manipulation\n",
    "    # df_raw_fd = gdf_raw_fd.to_pandas().dropna().iloc[:-1, 1]\n",
    "    \n",
    "    return gdf_raw_fd, weights"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Following is the gQuant's fractional differencing implementation via Numba library"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "def fractional_diff(input_arr, d=0.5, floor=1e-3, min_periods=None,\n",
      "                    thread_tile=2, number_of_threads=512):\n",
      "    \"\"\"\n",
      "    The fractional difference computation method.\n",
      "\n",
      "    Arguments:\n",
      "    -------\n",
      "      input_arr: numba.cuda.DeviceNDArray or cudf.Series\n",
      "        the input array to compute the fractional difference\n",
      "      d: float\n",
      "        the differencing value. range from 0 to 1\n",
      "      floor: float\n",
      "        minimum value for the weights for computational efficiency.\n",
      "      min_periods: int\n",
      "        default the lengths of the weights. Need at least min_periods of\n",
      "        non-na elements to get fractional difference value\n",
      "      thread_tile: int\n",
      "        each thread will be responsible for `thread_tile` number of\n",
      "        elements in window computation\n",
      "      number_of_threads: int\n",
      "        number of threads in a block for CUDA computation\n",
      "\n",
      "    Returns\n",
      "    -------\n",
      "    (numba.cuda.DeviceNDArray, np.array)\n",
      "        the computed fractional difference array and the weight array tuple\n",
      "\n",
      "    \"\"\"\n",
      "    if isinstance(input_arr, numba.cuda.cudadrv.devicearray.DeviceNDArray):\n",
      "        gpu_in = input_arr\n",
      "    else:\n",
      "        gpu_in = input_arr.to_gpu_array()\n",
      "\n",
      "    # compute the weights for the fractional difference\n",
      "    weights = get_weights_floored(d=d,\n",
      "                                  num_k=len(input_arr),\n",
      "                                  floor=floor)[::-1, 0]\n",
      "    weights_out = np.ascontiguousarray(weights)\n",
      "    weights = numba.cuda.to_device(weights_out)\n",
      "\n",
      "    window = len(weights)\n",
      "\n",
      "    if min_periods is None:\n",
      "        min_periods = window\n",
      "    else:\n",
      "        min_periods = min_periods\n",
      "\n",
      "    number_of_threads = number_of_threads\n",
      "    array_len = len(gpu_in)\n",
      "\n",
      "    # allocate the output array\n",
      "    gpu_out = numba.cuda.device_array_like(gpu_in)\n",
      "\n",
      "    number_of_blocks = \\\n",
      "        (array_len + (number_of_threads * thread_tile - 1)) // \\\n",
      "        (number_of_threads * thread_tile)\n",
      "\n",
      "    shared_buffer_size = (number_of_threads * thread_tile +\n",
      "                          window - 1 + window)\n",
      "\n",
      "    # call the conv kernel\n",
      "    kernel[(number_of_blocks,),\n",
      "           (number_of_threads,),\n",
      "           0,\n",
      "           shared_buffer_size * 8](gpu_in,\n",
      "                                   weights,\n",
      "                                   gpu_out,\n",
      "                                   window,\n",
      "                                   array_len,\n",
      "                                   thread_tile,\n",
      "                                   min_periods)\n",
      "    return gpu_out, weights_out\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(inspect.getsource(fractional_diff))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It launches the Numba kernel, which defined as:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "@cuda.jit(device=True)\n",
    "def conv_window(shared, history_len, out_arr, window_size,\n",
    "                arr_len, offset, offset2, min_size):\n",
    "    \"\"\"\n",
    "    This function is to do convolution for one thread\n",
    "\n",
    "    Arguments:\n",
    "    ------\n",
    "     shared: numba.cuda.DeviceNDArray\n",
    "        3 chunks of data are stored in the shared memory\n",
    "        the first [0, window_size) elements is the chunk of data that is\n",
    "        necessary to compute the first convolution element.\n",
    "        then [window_size, window_size + thread_tile * blockDim) elements\n",
    "        are the inputs allocated for this block of threads\n",
    "        the last [window_size + thread_tile,\n",
    "        window_size + thread_tile + window_size) is to store the kernel values\n",
    "     history_len: int\n",
    "        total number of historical elements available for this chunk of data\n",
    "     out_arr: numba.cuda.DeviceNDArray\n",
    "        output gpu_array of size of `thread_tile`\n",
    "     window_size: int\n",
    "        the number of elements in the kernel\n",
    "     arr_len: int\n",
    "        the chunk array length, same as `thread_tile`\n",
    "     offset: int\n",
    "        indicate the starting index of the chunk array in the shared for\n",
    "        this thread.\n",
    "     offset: int\n",
    "        indicate the starting position of the weights/kernel array\n",
    "     min_size: int\n",
    "         the minimum number of non-na elements\n",
    "    \"\"\"\n",
    "    for i in range(arr_len):\n",
    "        if i + history_len < window_size-1:\n",
    "            out_arr[i] = np.nan\n",
    "        else:\n",
    "            s = 0.0\n",
    "            average_size = 0\n",
    "            for j in range(0, window_size):\n",
    "                if not (cmath.isnan(\n",
    "                        shared[offset + i - j])):\n",
    "                    s += (shared[offset + i - j] *\n",
    "                          shared[offset2 + window_size - 1 - j])\n",
    "                    average_size += 1\n",
    "            if average_size >= min_size:\n",
    "                out_arr[i] = s\n",
    "            else:\n",
    "                out_arr[i] = np.nan\n",
    "\n",
    "                \n",
    "@cuda.jit\n",
    "def kernel(in_arr, weight_arr, out_arr, window,\n",
    "           arr_len, thread_tile, min_size):\n",
    "    \"\"\"\n",
    "    This kernel is to do 1D convlution on `in_arr` array with `weight_arr`\n",
    "    as kernel. The results is saved on `out_arr`.\n",
    "\n",
    "    Arguments:\n",
    "    ------\n",
    "     in_arr: numba.cuda.DeviceNDArray\n",
    "        input gpu array\n",
    "     weight_arr: numba.cuda.DeviceNDArray\n",
    "        convolution kernel gpu array\n",
    "     out_arr: numba.cuda.DeviceNDArray\n",
    "        output gpu_array\n",
    "     window: int\n",
    "        the number of elements in the weight_arr\n",
    "     arr_len: int\n",
    "        the input/output array length\n",
    "     thread_tile: int\n",
    "        each thread is responsible for `thread_tile` number of elements\n",
    "     min_size: int\n",
    "         the minimum number of non-na elements\n",
    "    \"\"\"\n",
    "    shared = cuda.shared.array(shape=0,\n",
    "                               dtype=numba.float64)\n",
    "    block_size = cuda.blockDim.x  # total number of threads\n",
    "    tx = cuda.threadIdx.x\n",
    "    # Block id in a 1D grid\n",
    "    bid = cuda.blockIdx.x\n",
    "    starting_id = bid * block_size * thread_tile\n",
    "\n",
    "    # copy the thread_tile * number_of_thread_per_block into the shared\n",
    "    for j in range(thread_tile):\n",
    "        offset = tx + j * block_size\n",
    "        if (starting_id + offset) < arr_len:\n",
    "            shared[offset + window - 1] = in_arr[\n",
    "                starting_id + offset]\n",
    "        cuda.syncthreads()\n",
    "\n",
    "    # copy the window - 1 into the shared\n",
    "    for j in range(0, window - 1, block_size):\n",
    "        if (((tx + j) <\n",
    "             window - 1) and (\n",
    "                 starting_id - window + 1 + tx + j >= 0)):\n",
    "            shared[tx + j] = \\\n",
    "                in_arr[starting_id - window + 1 + tx + j]\n",
    "        cuda.syncthreads()\n",
    "    # copy the weights into the shared\n",
    "    for j in range(0, window, block_size):\n",
    "        element_id = tx + j\n",
    "        if (((tx + j) < window) and (element_id < window)):\n",
    "            shared[thread_tile * block_size + window - 1 + tx +\n",
    "                   j] = weight_arr[tx + j]\n",
    "        cuda.syncthreads()\n",
    "    # slice the shared memory for each threads\n",
    "    start_shared = tx * thread_tile\n",
    "    his_len = min(window - 1,\n",
    "                  starting_id + tx * thread_tile)\n",
    "    # slice the global memory for each threads\n",
    "    start = starting_id + tx * thread_tile\n",
    "    end = min(starting_id + (tx + 1) * thread_tile, arr_len)\n",
    "    sub_outarr = out_arr[start:end]\n",
    "    sub_len = end - start\n",
    "    conv_window(shared, his_len, sub_outarr,\n",
    "                window, sub_len,\n",
    "                window - 1 + start_shared,\n",
    "                thread_tile * block_size + window - 1,\n",
    "                min_size)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Fractional differencing is essentially doing 1D convolution computation with the kernel values set to be the weights computed from get_weights_floored. Check the original notebook for the details of the meanings of the weights. To make convolution computation faster, we divide the long input array into small chunks and send to different thread blocks. All the array chunks and the weights are loaded into the GPU shared memory for fast IO. The device function conv_window is doing the convolution computation for one thread.\n",
    "\n",
    "To make a fair comparsion with CPU implementation, we implemented an efficient CPU version of the fractional differencing calculation. It is accelerated by numba.njit that take advantage of multiple cores of the CPU and fastmath compiler optimization."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "@njit(fastmath=True, parallel=True)\n",
    "def moving_dot_product_cpu(in_data, out, window_size, weights):\n",
    "    # Set the first window_size-1 rows in each chunk to np.nan due \n",
    "    # insufficient history\n",
    "    for i in prange(0, window_size - 1):\n",
    "        out[i] = np.nan\n",
    "    \n",
    "    # Compute dot product of preceding window_size rows\n",
    "    for i in prange(window_size - 1, len(in_data)):\n",
    "        rolling_dot_product = 0.0\n",
    "        \n",
    "        k = 0\n",
    "        for j in range(i - window_size + 1, i + 1):\n",
    "            rolling_dot_product += in_data[j] * weights[k]\n",
    "            k += 1\n",
    "        \n",
    "        out[i] = rolling_dot_product \n",
    "\n",
    "def cpu_fractional_diff(input_arr, d=0.5, floor=1e-3):\n",
    "\n",
    "    # compute the weights for the fractional difference\n",
    "    weights = get_weights_floored(d=d,\n",
    "                                  num_k=len(input_arr),\n",
    "                                  floor=floor)[::-1, 0]\n",
    "    weights_out = np.ascontiguousarray(weights)\n",
    "    weights = weights_out\n",
    "    weights_window_size = len(weights)\n",
    "    window = len(weights)\n",
    "    out = np.zeros_like(input_arr)\n",
    "    moving_dot_product_cpu(input_arr, out, weights_window_size, weights)\n",
    "    return out"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Fractional differencing is essentially doing 1D convolution computation with the kernel values set to be the weights computed from `get_weights_floored`. Check the original [notebook](https://github.com/ritchieng/fractional_differencing_gpu/blob/master/notebooks/gpu_fractional_differencing.ipynb) for the details of the meanings of the weights. To make convolution computation faster, we divide the long input array into small chunks and send to different thread blocks. All the array chunks and the weights are loaded into the GPU shared memory for fast IO. The device function `conv_window` is doing the convolution computation for one thread.\n",
    "\n",
    "We can compare the performance of gQuant GPU implementation vs the original one and CPU implementation:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "array size 100000, Ensemble: time 0.404 s, gQuant GPU Time 0.483 s, gQuant CPU Time 0.742, speed up 0.84, speed up vs CPU 1.54, error 0.0000 \n",
      "array size 1000000, Ensemble: time 0.085 s, gQuant GPU Time 0.007 s, gQuant CPU Time 0.042, speed up 12.07, speed up vs CPU 5.98, error 0.0000 \n",
      "array size 10000000, Ensemble: time 0.774 s, gQuant GPU Time 0.010 s, gQuant CPU Time 0.287, speed up 78.79, speed up vs CPU 29.26, error 0.0000 \n",
      "array size 100000000, Ensemble: time 6.987 s, gQuant GPU Time 0.052 s, gQuant CPU Time 2.533, speed up 133.71, speed up vs CPU 48.47, error 0.0000 \n"
     ]
    }
   ],
   "source": [
    "for i in range(5, 9):\n",
    "    df_raw = cudf.DataFrame()\n",
    "    ran_array = np.random.rand(10**int(i))\n",
    "    df_raw['in'] = ran_array\n",
    "    df_raw2 = cudf.DataFrame()\n",
    "    df_raw2['in'] = ran_array\n",
    "\n",
    "    # Start timer\n",
    "    start = time.time()\n",
    "    df_raw_fd_from_gpu, weights = frac_diff_gpu(df_raw, d=0.5, floor=5e-5)\n",
    "    # End timer\n",
    "    end = time.time()\n",
    "    duration = end - start\n",
    "\n",
    "    start = time.time()\n",
    "    gquant_gpu, weights = fractional_diff(df_raw2['in'], d=0.5, floor=5e-5)\n",
    "    cuda.synchronize()\n",
    "    end = time.time()\n",
    "    optimized_duration = end - start\n",
    "    #(df_raw_fd_from_gpu.values)\n",
    "    \n",
    "    \n",
    "    start = time.time()\n",
    "    cpu_result = cpu_fractional_diff(ran_array, d=0.5, floor=5e-5)\n",
    "    end = time.time()\n",
    "    cpu_duration = end - start\n",
    "    \n",
    "    err = np.abs(df_raw_fd_from_gpu['out'].to_array()[weights.size-1:] - np.array(gquant_gpu)[weights.size-1:]).max()\n",
    "    err = max(np.abs(df_raw_fd_from_gpu['out'].to_array()[weights.size-1:] - cpu_result[weights.size-1:]).max(), err)\n",
    "    print('array size %d, Ensemble: time %.3f s, gQuant GPU Time %.3f s, gQuant CPU Time %.3f, speed up %.2f, speed up vs CPU %.2f, error %.4f ' % (10**int(i), duration, optimized_duration, cpu_duration, duration / optimized_duration, cpu_duration/optimized_duration, err))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For the array of length 100m, gQuant can achieve 100x speedup compare with the Ensemble Capitial's GPU implementatoin and 30x speed up compared with multiple core CPU."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Use the fractional differencing signal to trade stocks\n",
    "\n",
    "We will use the same [XGBoost example](https://github.com/rapidsai/gQuant/blob/master/notebooks/06_xgboost_trade.ipynbx) to do backtest with fractional differencing signals. The workflow includes the following steps:\n",
    "\n",
    "1. Load the 5000 end-of-day stocks CSV data into the dataframe\n",
    "\n",
    "2. Add rate of return feature to the dataframe.\n",
    "\n",
    "3. Clean up the data by removing low volume stocks and extreme rate of returns stocks.\n",
    "\n",
    "4. Compute the features based on different fractional differencing signals of the closing prices of the stocks \n",
    "\n",
    "5. Split the data in training and testing and build a XGBoost model based on the training data. From the XGBoost model, compute the trading signals for all the data points.\n",
    "\n",
    "5. Run backtesting and compute the returns from this strategy for each of the days and stock symbols \n",
    "\n",
    "6. Run a simple portfolio optimization by averaging the stocks together for each of the trading days.\n",
    "\n",
    "7. Compute the Sharpe ratio and cumulative return results for both training and testing datasets\n",
    "\n",
    "The whole workflow can be organized into a computation graph, which are fully described in a yaml file. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Each nodes has a unique id, a node type, configuration parameters and input nodes ids. gQuant takes this yaml file, wires it into a graph to visualize it. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%reset -s -f\n",
    "import sys\n",
    "import os\n",
    "sys.path.append('..')\n",
    "import gquant\n",
    "from gquant.dataframe_flow import TaskGraph\n",
    "import ipywidgets as widgets\n",
    "import warnings\n",
    "warnings.simplefilter(\"ignore\")\n",
    "\n",
    "task_graph = TaskGraph.load_taskgraph('../task_example/xgboost_trade.yaml')\n",
    "task_graph.draw(show='ipynb')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Define some constants for the data filters. If using GPU of 32G memory, you can safely set the min_volume to 5.0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "min_volume = 400.0\n",
    "min_rate = -10.0\n",
    "max_rate = 10.0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The features used for XGBoost algorithm are prepared in the `node_technical_indicator` node, where `cuIndicator` module is used to compute the technical indicators in the GPU for all the stock symbols. `node_xgboost_strategy` is the node that is used to compute the trading signals from the stock technical indicators. Each of the gQuant node is implemented by overwriting \"columns_setup\" and \"process\" methods of the Node base class. Please refer to [customize nodes notebook](https://github.com/rapidsai/gQuant/blob/master/notebooks/05_customize_nodes.ipynb) for details. Define the function to visualize the backtest results "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# define the function to format the plots\n",
    "def plot_figures(o):\n",
    "    # format the figures\n",
    "    figure_width = '1200px'\n",
    "    figure_height = '400px'\n",
    "    sharpe_number = o[0]\n",
    "    cum_return_train = o[1]\n",
    "    cum_return_train.layout.height = figure_height\n",
    "    cum_return_train.layout.width = figure_width\n",
    "    cum_return_train.title = 'Training P & L %.3f' % (sharpe_number)\n",
    "    sharpe_number = o[2]\n",
    "    cum_return_test = o[3]\n",
    "    cum_return_test.layout.height = figure_height\n",
    "    cum_return_test.layout.width = figure_width\n",
    "    cum_return_test.title = 'Testing P & L %.3f' % (sharpe_number)\n",
    "\n",
    "    return widgets.VBox([cum_return_train, cum_return_test])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this example, we are going to add 5 fractional differencing signals from the closing prices "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "indicator_conf = {\n",
    "    \"indicators\": [\n",
    "        {\"function\": \"port_fractional_diff\",\n",
    "         \"columns\": [\"close\"],\n",
    "         \"args\": [0.5]\n",
    "        },\n",
    "        {\"function\": \"port_fractional_diff\",\n",
    "         \"columns\": [\"close\"],\n",
    "         \"args\": [0.3]\n",
    "        },\n",
    "        {\"function\": \"port_fractional_diff\",\n",
    "         \"columns\": [\"close\"],\n",
    "         \"args\": [0.1]\n",
    "        },\n",
    "        {\"function\": \"port_fractional_diff\",\n",
    "         \"columns\": [\"close\"],\n",
    "         \"args\": [0.7]\n",
    "        },\n",
    "        {\"function\": \"port_fractional_diff\",\n",
    "         \"columns\": [\"close\"],\n",
    "         \"args\": [0.9]\n",
    "        },\n",
    "        {\"function\": \"port_shift\",\n",
    "         \"columns\": [\"returns\"],\n",
    "         \"args\": [-1]\n",
    "        }        \n",
    "    ],\n",
    "    \"remove_na\": True\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Run the backtest"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "04598428378f472b8082afae88dd699f",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "VBox(children=(Figure(axes=[Axis(label='Cumulative return', orientation='vertical', scale=LinearScale()), Axis…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "action = \"load\" if os.path.isfile('./.cache/node_csvdata.hdf5') else \"save\"\n",
    "outlist = ['node_sharpe_training','node_cumlativeReturn_training', 'node_sharpe_testing', 'node_cumlativeReturn_testing']\n",
    "replace_spec={'node_filterValue': {\"conf\": [{\"column\": \"volume_mean\", \"min\": min_volume},\n",
    "                                            {\"column\": \"returns_max\", \"max\": max_rate},\n",
    "                                            {\"column\": \"returns_min\", \"min\": min_rate}]},\n",
    "              'node_csvdata': {action: True}}\n",
    "replace_spec['node_technical_indicator'] = {\"conf\": indicator_conf}\n",
    "#replace_spec['node_sort2'] = {\"load\": cached_sort}\n",
    "o_gpu = task_graph.run(\n",
    "            outputs=outlist,\n",
    "            replace=replace_spec)\n",
    "plot_figures(o_gpu)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We get Sharpe Ratio of `1.01` just from the fractional differencing signals of the closing prices\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To visualize the computed fractional differencing signals, we can add a branch to the graph for plotting. In the example below, we select the asset with id `22123` and plot 4 fractional differencing signals with different `d` values. Check the updated graph below"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "asset_filter = {    'id': 'node_filter_asset',\n",
    "    'type': \"AssetFilterNode\",\n",
    "    'conf': {\n",
    "        \"asset\": 22123\n",
    "    },\n",
    "    \"inputs\": [\"node_technical_indicator\"]\n",
    "}\n",
    "\n",
    "node_lines ={\n",
    "    \"id\": \"node_lineplot\",\n",
    "    \"type\": \"LinePlotNode\",\n",
    "    \"conf\": { \"points\": 300,\n",
    "    \"lines\":\n",
    "         [ {\"column\": \"FR_DI_0.1\",\n",
    "            \"label\": \"d 0.1\",\n",
    "            \"color\": \"blue\"},\n",
    "          {\"column\": \"FR_DI_0.3\",\n",
    "            \"label\": \"d 0.3\",\n",
    "            \"color\": \"orange\"},\n",
    "          {\"column\": \"FR_DI_0.5\",\n",
    "           \"label\": \"d 0.5\",\n",
    "           \"color\": \"green\"},\n",
    "          {\"column\": \"FR_DI_0.7\",\n",
    "           \"label\": \"d 0.7\",\n",
    "           \"color\": \"black\"}\n",
    "         ],\n",
    "     \"title\": \"Signals\"},\n",
    "   \"inputs\": [\"node_filter_asset\"]}\n",
    "task_graph.extend([asset_filter, node_lines])\n",
    "task_graph.draw(show='ipynb')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can run the sub-graph just for plotting the signals."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "62ff240e01f24dc28e2fa8f74be67832",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Figure(axes=[Axis(orientation='vertical', scale=LinearScale()), Axis(label='Time', scale=DateScale())], fig_ma…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "action = \"load\" if os.path.isfile('./.cache/node_csvdata.hdf5') else \"save\"\n",
    "outlist = ['node_lineplot']\n",
    "replace_spec={'node_filterValue': {\"conf\": [{\"column\": \"volume_mean\", \"min\": min_volume},\n",
    "                                            {\"column\": \"returns_max\", \"max\": max_rate},\n",
    "                                            {\"column\": \"returns_min\", \"min\": min_rate}]},\n",
    "              'node_csvdata': {action: True}}\n",
    "replace_spec['node_technical_indicator'] = {\"conf\": indicator_conf}\n",
    "#replace_spec['node_sort2'] = {\"load\": cached_sort}\n",
    "(lineplot, ) = task_graph.run(outputs=outlist,\n",
    "                              replace=replace_spec)\n",
    "# display plot in jupyter\n",
    "lineplot"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note, smaller `d` value signal has more memory information but not as stationary as the high `d` value signals. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Conclusions\n",
    "In this notebook, we demoed how to use Numba to implemement fractional differencing calculation in GPU. It achieves 100x speed up compared with the method done by Ensemble Capital. We also showed it is easy to use gQuant to compute fractional difference and run backtests"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
